జావాస్క్రిప్ట్ అసింక్ జెనరేటర్ హెల్పర్స్: స్ట్రీమ్ సృష్టి మరియు నిర్వహణలో నైపుణ్యం సాధించడం

జావాస్క్రిప్ట్‌లో అసింక్రోనస్ ప్రోగ్రామింగ్ సంవత్సరాలుగా గణనీయంగా అభివృద్ధి చెందింది. అసింక్ జెనరేటర్లు మరియు అసింక్ ఇటరేటర్ల పరిచయంతో, డెవలపర్లు అసింక్రోనస్ డేటా స్ట్రీమ్‌లను నిర్వహించడానికి శక్తివంతమైన సాధనాలను పొందారు. ఇప్పుడు, జావాస్క్రిప్ట్ అసింక్ జెనరేటర్ హెల్పర్స్ ఈ సామర్థ్యాలను మరింత మెరుగుపరుస్తాయి, అసింక్రోనస్ డేటా స్ట్రీమ్‌లను సృష్టించడానికి, మార్చడానికి మరియు నిర్వహించడానికి మరింత క్రమబద్ధమైన మరియు వ్యక్తీకరణ మార్గాన్ని అందిస్తాయి. ఈ గైడ్ అసింక్ జెనరేటర్ హెల్పర్స్ యొక్క ప్రాథమికాలను అన్వేషిస్తుంది, వాటి కార్యాచరణలను పరిశోధిస్తుంది మరియు స్పష్టమైన ఉదాహరణలతో వాటి ఆచరణాత్మక అనువర్తనాలను ప్రదర్శిస్తుంది.

అసింక్ జెనరేటర్లు మరియు ఇటరేటర్లను అర్థం చేసుకోవడం

అసింక్ జెనరేటర్ హెల్పర్స్‌లోకి వెళ్లే ముందు, అసింక్ జెనరేటర్లు మరియు అసింక్ ఇటరేటర్ల యొక్క ప్రాథమిక భావనలను అర్థం చేసుకోవడం చాలా ముఖ్యం.

అసింక్ జెనరేటర్లు

ఒక అసింక్ జెనరేటర్ అనేది ఒక ఫంక్షన్, దీనిని పాజ్ చేసి పునఃప్రారంభించవచ్చు, ఇది అసింక్రోనస్‌గా విలువలను ఇస్తుంది. ఇది ప్రధాన థ్రెడ్‌ను నిరోధించకుండా, కాలక్రమేణా విలువల శ్రేణిని రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది. అసింక్ జెనరేటర్లు async function* సింటాక్స్ ఉపయోగించి నిర్వచించబడతాయి.

ఉదాహరణ:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // అసింక్రోనస్ ఆపరేషన్‌ను అనుకరించడం
    yield i;
  }
}

// వినియోగం
const sequence = generateSequence(1, 5);

అసింక్ ఇటరేటర్లు

ఒక అసింక్ ఇటరేటర్ అనేది ఒక ఆబ్జెక్ట్, ఇది next() పద్ధతిని అందిస్తుంది, ఇది శ్రేణిలోని తదుపరి విలువను మరియు శ్రేణి ముగిసిందో లేదో సూచించే done ప్రాపర్టీని కలిగి ఉన్న ఆబ్జెక్ట్‌కు పరిష్కరించబడే ప్రామిస్‌ను అందిస్తుంది. అసింక్ ఇటరేటర్లు for await...of లూప్‌లను ఉపయోగించి వినియోగించబడతాయి.

ఉదాహరణ:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500));
    yield i;
  }
}

async function consumeSequence() {
  const sequence = generateSequence(1, 5);
  for await (const value of sequence) {
    console.log(value);
  }
}

consumeSequence();

అసింక్ జెనరేటర్ హెల్పర్స్ పరిచయం

అసింక్ జెనరేటర్ హెల్పర్స్ అనేవి అసింక్ జెనరేటర్ ప్రోటోటైప్‌ల కార్యాచరణను విస్తరించే పద్ధతుల సమితి. అవి అసింక్రోనస్ డేటా స్ట్రీమ్‌లను మార్చడానికి అనుకూలమైన మార్గాలను అందిస్తాయి, కోడ్‌ను మరింత చదవగలిగేలా మరియు నిర్వహించగలిగేలా చేస్తాయి. ఈ హెల్పర్స్ సోమరితనంతో పనిచేస్తాయి, అంటే అవి అవసరమైనప్పుడు మాత్రమే డేటాను ప్రాసెస్ చేస్తాయి, ఇది పనితీరును మెరుగుపరుస్తుంది.

కింది అసింక్ జెనరేటర్ హెల్పర్స్ సాధారణంగా అందుబాటులో ఉంటాయి (జావాస్క్రిప్ట్ ఎన్విరాన్‌మెంట్ మరియు పాలీఫిల్స్‌పై ఆధారపడి):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

అసింక్ జెనరేటర్ హెల్పర్స్ యొక్క వివరణాత్మక అన్వేషణ

1. `map()`

map() హెల్పర్ అందించిన ఫంక్షన్‌ను వర్తింపజేయడం ద్వారా అసింక్రోనస్ శ్రేణిలోని ప్రతి విలువను మారుస్తుంది. ఇది రూపాంతరం చెందిన విలువలను ఇచ్చే కొత్త అసింక్ జెనరేటర్‌ను అందిస్తుంది.

సింటాక్స్:

asyncGenerator.map(callback)

ఉదాహరణ: సంఖ్యల స్ట్రీమ్‌ను వాటి వర్గాలుగా మార్చడం.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // అసింక్ ఆపరేషన్‌ను అనుకరించడం
    return num * num;
  });

  for await (const square of squares) {
    console.log(square);
  }
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: బహుళ APIల నుండి యూజర్ డేటాను పొంది, ఆ డేటాను ఒక స్థిరమైన ఫార్మాట్‌లోకి మార్చాల్సిన అవసరం ఉందని ఊహించుకోండి. map() ప్రతి యూజర్ ఆబ్జెక్ట్‌కు అసింక్రోనస్‌గా పరివర్తన ఫంక్షన్‌ను వర్తింపజేయడానికి ఉపయోగించబడుతుంది.

async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // యూజర్ డేటా ఫార్మాట్‌ను నార్మలైజ్ చేయడం
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

  for await (const normalizedUser of normalizedUsers) {
    console.log(normalizedUser);
  }
}

2. `filter()`

filter() హెల్పర్ అందించిన షరతును సంతృప్తిపరిచే అసలు శ్రేణి నుండి మాత్రమే విలువలను ఇచ్చే కొత్త అసింక్ జెనరేటర్‌ను సృష్టిస్తుంది. ఇది ఫలిత స్ట్రీమ్‌లో విలువలను ఎంపిక చేసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.

సింటాక్స్:

asyncGenerator.filter(callback)

ఉదాహరణ: సరి సంఖ్యలను మాత్రమే చేర్చడానికి సంఖ్యల స్ట్రీమ్‌ను ఫిల్టర్ చేయడం.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

  for await (const evenNumber of evenNumbers) {
    console.log(evenNumber);
  }
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: లాగ్ ఎంట్రీల స్ట్రీమ్‌ను ప్రాసెస్ చేయడం మరియు వాటి తీవ్రత స్థాయి ఆధారంగా ఎంట్రీలను ఫిల్టర్ చేయడం. ఉదాహరణకు, కేవలం ఎర్రర్‌లు మరియు హెచ్చరికలను మాత్రమే ప్రాసెస్ చేయడం.

async function* readLogFile(filePath) {
  // లాగ్ ఫైల్‌ను అసింక్రోనస్‌గా లైన్ ద్వారా చదవడం అనుకరించడం
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

  for await (const log of errorAndWarningLogs) {
    console.log(log);
  }
}

3. `take()`

take() హెల్పర్ అసలు శ్రేణి నుండి మొదటి n విలువలను మాత్రమే ఇచ్చే కొత్త అసింక్ జెనరేటర్‌ను సృష్టిస్తుంది. ఇది అనంతమైన లేదా చాలా పెద్ద స్ట్రీమ్ నుండి ప్రాసెస్ చేయబడిన ఐటెమ్‌ల సంఖ్యను పరిమితం చేయడానికి ఉపయోగపడుతుంది.

సింటాక్స్:

asyncGenerator.take(n)

ఉదాహరణ: సంఖ్యల స్ట్రీమ్ నుండి మొదటి 3 సంఖ్యలను తీసుకోవడం.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

  for await (const num of firstThree) {
    console.log(num);
  }
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: ఒక అసింక్రోనస్ సెర్చ్ API నుండి మొదటి 5 సెర్చ్ ఫలితాలను ప్రదర్శించడం.

async function* search(query) {
  // ఒక API నుండి సెర్చ్ ఫలితాలను పొందడం అనుకరించడం
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

  for await (const result of top5Results) {
    console.log(result);
  }
}

4. `drop()`

drop() హెల్పర్ అసలు శ్రేణి నుండి మొదటి n విలువలను వదిలివేసి, మిగిలిన విలువలను ఇచ్చే కొత్త అసింక్ జెనరేటర్‌ను సృష్టిస్తుంది. ఇది take() కి వ్యతిరేకం మరియు ఒక స్ట్రీమ్ యొక్క ప్రారంభ భాగాలను విస్మరించడానికి ఉపయోగపడుతుంది.

సింటాక్స్:

asyncGenerator.drop(n)

ఉదాహరణ: సంఖ్యల స్ట్రీమ్ నుండి మొదటి 2 సంఖ్యలను వదిలివేయడం.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

  for await (const num of remainingNumbers) {
    console.log(num);
  }
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: ఒక API నుండి పొందిన పెద్ద డేటాసెట్‌ ద్వారా పేజినేట్ చేయడం, ఇప్పటికే ప్రదర్శించబడిన ఫలితాలను దాటవేయడం.

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // ఆఫ్‌సెట్‌తో డేటాను పొందడం అనుకరించడం
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // మునుపటి పేజీల నుండి ఐటెమ్‌లను దాటవేయండి

  const results = page.take(pageSize);


  for await (const item of results) {
    console.log(item);
  }
}

// ఉదాహరణ వినియోగం
displayPage(2);

5. `flatMap()`

flatMap() హెల్పర్ ఒక అసింక్ ఇటరేబుల్‌ను తిరిగి ఇచ్చే ఫంక్షన్‌ను వర్తింపజేయడం ద్వారా అసింక్రోనస్ శ్రేణిలోని ప్రతి విలువను మారుస్తుంది. ఆ తర్వాత, ఫలిత అసింక్ ఇటరేబుల్‌ను ఒకే అసింక్ జెనరేటర్‌గా ఫ్లాట్ చేస్తుంది. ఇది ప్రతి విలువను విలువల స్ట్రీమ్‌గా మార్చడానికి, ఆపై ఆ స్ట్రీమ్‌లను కలపడానికి ఉపయోగపడుతుంది.

సింటాక్స్:

asyncGenerator.flatMap(callback)

ఉదాహరణ: వాక్యాల స్ట్రీమ్‌ను పదాల స్ట్రీమ్‌గా మార్చడం.

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

  for await (const word of words) {
    console.log(word);
  }
}

processSentences();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: బహుళ బ్లాగ్ పోస్ట్‌ల కోసం వ్యాఖ్యలను పొంది, వాటిని ప్రాసెసింగ్ కోసం ఒకే స్ట్రీమ్‌లో కలపడం.

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // ఒక API నుండి బ్లాగ్ పోస్ట్ ఐడిలను పొందడం అనుకరించడం
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // ఒక API నుండి ఒక బ్లాగ్ పోస్ట్ కోసం వ్యాఖ్యలను పొందడం అనుకరించడం
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

  for await (const comment of allComments) {
    console.log(comment);
  }
}

6. `reduce()`

reduce() హెల్పర్ ఒక అక్యుమ్యులేటర్ మరియు అసింక్ జెనరేటర్ యొక్క ప్రతి విలువకు (ఎడమ నుండి కుడికి) ఒక ఫంక్షన్‌ను వర్తింపజేసి, దానిని ఒకే విలువకు తగ్గిస్తుంది. ఇది ఒక అసింక్రోనస్ స్ట్రీమ్ నుండి డేటాను సమీకరించడానికి ఉపయోగపడుతుంది.

సింటాక్స్:

asyncGenerator.reduce(callback, initialValue)

ఉదాహరణ: ఒక స్ట్రీమ్‌లోని సంఖ్యల మొత్తాన్ని లెక్కించడం.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Sum:', sum);
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: వరుస API కాల్స్ యొక్క సగటు ప్రతిస్పందన సమయాన్ని లెక్కించడం.

async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`Error fetching ${endpoint}: ${error}`);
      yield 0; // లేదా లోపాన్ని సముచితంగా నిర్వహించండి
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`Average response time: ${average} ms`);
}

7. `toArray()`

toArray() హెల్పర్ అసింక్ జెనరేటర్‌ను వినియోగించుకుని, జెనరేటర్ ద్వారా యీల్డ్ చేయబడిన అన్ని విలువలను కలిగి ఉన్న ఒక అర్రేకు పరిష్కరించబడే ప్రామిస్‌ను అందిస్తుంది. ఇది స్ట్రీమ్ నుండి అన్ని విలువలను ఒకే అర్రేలో సేకరించి, తదుపరి ప్రాసెసింగ్ కోసం అవసరమైనప్పుడు ఉపయోగపడుతుంది.

సింటాక్స్:

asyncGenerator.toArray()

ఉదాహరణ: ఒక స్ట్రీమ్ నుండి సంఖ్యలను ఒక అర్రేలో సేకరించడం.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Number Array:', numberArray);
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: పేజినేటెడ్ API నుండి అన్ని ఐటెమ్‌లను క్లయింట్-సైడ్ ఫిల్టరింగ్ లేదా సార్టింగ్ కోసం ఒకే అర్రేలో సేకరించడం.

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // API యొక్క పేజినేషన్ పరిమితుల ఆధారంగా సర్దుబాటు చేయండి

    while (true) {
        const url = `${apiEndpoint}?page=${pageNumber}&pageSize=${pageSize}`;
        const response = await fetch(url);
        const data = await response.json();

        if (!data || data.length === 0) {
            break; // ఇక డేటా లేదు
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`Fetched ${itemsArray.length} items.`);
    // `itemsArray` పై తదుపరి ప్రాసెసింగ్ చేయవచ్చు
}

8. `forEach()`

forEach() హెల్పర్ అసింక్ జెనరేటర్‌లోని ప్రతి విలువకు ఒకసారి అందించిన ఫంక్షన్‌ను అమలు చేస్తుంది. ఇతర హెల్పర్ల వలె కాకుండా, forEach() కొత్త అసింక్ జెనరేటర్‌ను తిరిగి ఇవ్వదు; ఇది ప్రతి విలువపై సైడ్ ఎఫెక్ట్‌లను నిర్వహించడానికి ఉపయోగించబడుతుంది.

సింటాక్స్:

asyncGenerator.forEach(callback)

ఉదాహరణ: ఒక స్ట్రీమ్‌లోని ప్రతి సంఖ్యను కన్సోల్‌కు లాగ్ చేయడం.

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Number:', num);
  });
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: ఒక స్ట్రీమ్ నుండి డేటా ప్రాసెస్ చేయబడుతున్నప్పుడు ఒక యూజర్ ఇంటర్‌ఫేస్‌కు రియల్-టైమ్ అప్‌డేట్‌లను పంపడం.

async function* fetchRealTimeData(dataSource) {
    //రియల్-టైమ్ డేటాను (ఉదా. స్టాక్ ధరలు) పొందడం అనుకరించడం.
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    //UIని అప్‌డేట్ చేయడం అనుకరించడం
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // వాస్తవానికి UIని అప్‌డేట్ చేసే కోడ్ ఇక్కడ ఉంటుంది.
  });
}

సంక్లిష్ట డేటా పైప్‌లైన్‌ల కోసం అసింక్ జెనరేటర్ హెల్పర్‌లను కలపడం

అసింక్ జెనరేటర్ హెల్పర్‌ల యొక్క నిజమైన శక్తి సంక్లిష్ట డేటా పైప్‌లైన్‌లను సృష్టించడానికి వాటిని కలిసి గొలుసుగా చేర్చగల సామర్థ్యం నుండి వస్తుంది. ఇది ఒక అసింక్రోనస్ స్ట్రీమ్‌పై బహుళ పరివర్తనలు మరియు ఆపరేషన్‌లను ఒక సంక్షిప్త మరియు చదవగలిగే విధంగా నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఉదాహరణ: ఒక సంఖ్యల స్ట్రీమ్‌ను సరి సంఖ్యలను మాత్రమే చేర్చడానికి ఫిల్టర్ చేయడం, ఆపై వాటిని వర్గం చేయడం, మరియు చివరిగా మొదటి 3 ఫలితాలను తీసుకోవడం.

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

  for await (const num of processedNumbers) {
    console.log(num);
  }
}

processNumbers();

వాస్తవ-ప్రపంచ వినియోగ సందర్భం: యూజర్ డేటాను పొందడం, వారి లొకేషన్ ఆధారంగా యూజర్‌లను ఫిల్టర్ చేయడం, వారి డేటాను సంబంధిత ఫీల్డ్‌లను మాత్రమే చేర్చడానికి మార్చడం, ఆపై మొదటి 10 యూజర్‌లను మ్యాప్‌లో ప్రదర్శించడం.

async function* fetchUsers() {
  // ఒక డేటాబేస్ లేదా API నుండి యూజర్‌లను పొందడం అనుకరించడం
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// వినియోగ ఉదాహరణలు:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

పాలీఫిల్స్ మరియు బ్రౌజర్ మద్దతు

అసింక్ జెనరేటర్ హెల్పర్‌ల మద్దతు జావాస్క్రిప్ట్ ఎన్విరాన్‌మెంట్‌పై ఆధారపడి మారవచ్చు. మీరు పాత బ్రౌజర్‌లు లేదా ఎన్విరాన్‌మెంట్‌లకు మద్దతు ఇవ్వవలసి వస్తే, మీరు పాలీఫిల్స్‌ను ఉపయోగించవలసి రావచ్చు. ఒక పాలీఫిల్ జావాస్క్రిప్ట్‌లో అమలు చేయడం ద్వారా తప్పిపోయిన కార్యాచరణను అందిస్తుంది. అసింక్ జెనరేటర్ హెల్పర్‌ల కోసం core-js వంటి అనేక పాలీఫిల్ లైబ్రరీలు అందుబాటులో ఉన్నాయి.

core-js ఉపయోగించి ఉదాహరణ:

// అవసరమైన పాలీఫిల్స్‌ను ఇంపోర్ట్ చేయండి
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... అవసరమైన ఇతర హెల్పర్లను ఇంపోర్ట్ చేయండి

ఎర్రర్ హ్యాండ్లింగ్

అసింక్రోనస్ ఆపరేషన్‌లతో పనిచేస్తున్నప్పుడు, ఎర్రర్‌లను సరిగ్గా నిర్వహించడం చాలా ముఖ్యం. అసింక్ జెనరేటర్ హెల్పర్‌లతో, హెల్పర్లలో ఉపయోగించే అసింక్రోనస్ ఫంక్షన్‌లలో try...catch బ్లాక్‌లను ఉపయోగించి ఎర్రర్ హ్యాండ్లింగ్ చేయవచ్చు.

ఉదాహరణ: ఒక map() ఆపరేషన్‌లో డేటాను పొందుతున్నప్పుడు ఎర్రర్‌లను నిర్వహించడం.

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // లేదా లోపాన్ని సముచితంగా నిర్వహించండి, ఉదా., ఒక ఎర్రర్ ఆబ్జెక్ట్‌ను యీల్డ్ చేయడం ద్వారా
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // లోపాన్ని ప్రచారం చేయండి
    }
    // డేటాను ప్రాసెస్ చేయండి
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

ఉత్తమ పద్ధతులు మరియు పరిగణనలు

• సోమరి మూల్యాంకనం (Lazy Evaluation): అసింక్ జెనరేటర్ హెల్పర్‌లు సోమరితనంతో మూల్యాంకనం చేయబడతాయి, అంటే అవి అభ్యర్థించినప్పుడు మాత్రమే డేటాను ప్రాసెస్ చేస్తాయి. ఇది పనితీరును మెరుగుపరుస్తుంది, ముఖ్యంగా పెద్ద డేటాసెట్‌లతో వ్యవహరించేటప్పుడు.
• ఎర్రర్ హ్యాండ్లింగ్: హెల్పర్లలో ఉపయోగించే అసింక్రోనస్ ఫంక్షన్‌లలో ఎల్లప్పుడూ లోపాలను సరిగ్గా నిర్వహించండి.
• పాలీఫిల్స్: పాత బ్రౌజర్‌లు లేదా ఎన్విరాన్‌మెంట్‌లకు మద్దతు ఇవ్వడానికి అవసరమైనప్పుడు పాలీఫిల్స్‌ను ఉపయోగించండి.
• చదవడానికి అనువుగా (Readability): మీ కోడ్‌ను మరింత చదవగలిగేలా మరియు నిర్వహించగలిగేలా చేయడానికి వివరణాత్మక వేరియబుల్ పేర్లు మరియు వ్యాఖ్యలను ఉపయోగించండి.
• పనితీరు: బహుళ హెల్పర్లను కలిసి గొలుసుగా చేర్చడం వల్ల కలిగే పనితీరు ప్రభావాల గురించి జాగ్రత్తగా ఉండండి. సోమరితనం సహాయపడినప్పటికీ, అధిక గొలుసు ఇప్పటికీ ఓవర్‌హెడ్‌ను పరిచయం చేస్తుంది.

ముగింపు

జావాస్క్రిప్ట్ అసింక్ జెనరేటర్ హెల్పర్‌లు అసింక్రోనస్ డేటా స్ట్రీమ్‌లను సృష్టించడానికి, మార్చడానికి మరియు నిర్వహించడానికి ఒక శక్తివంతమైన మరియు సొగసైన మార్గాన్ని అందిస్తాయి. ఈ హెల్పర్లను ఉపయోగించడం ద్వారా, డెవలపర్లు సంక్లిష్ట అసింక్రోనస్ ఆపరేషన్‌లను నిర్వహించడానికి మరింత సంక్షిప్త, చదవగలిగే మరియు నిర్వహించగలిగే కోడ్‌ను వ్రాయగలరు. అసింక్ జెనరేటర్లు మరియు ఇటరేటర్ల యొక్క ప్రాథమికాలను, అలాగే ప్రతి హెల్పర్ యొక్క కార్యాచరణలను అర్థం చేసుకోవడం, వాస్తవ-ప్రపంచ అనువర్తనాలలో ఈ సాధనాలను సమర్థవంతంగా ఉపయోగించుకోవడానికి అవసరం. మీరు డేటా పైప్‌లైన్‌లను నిర్మిస్తున్నా, రియల్-టైమ్ డేటాను ప్రాసెస్ చేస్తున్నా, లేదా అసింక్రోనస్ API ప్రతిస్పందనలను నిర్వహిస్తున్నా, అసింక్ జెనరేటర్ హెల్పర్‌లు మీ కోడ్‌ను గణనీయంగా సరళీకరించి, దాని మొత్తం సామర్థ్యాన్ని మెరుగుపరుస్తాయి.